home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / game / shoot / ADoomPPC_src.lha / ADoomPPC_src / p_saveg.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-14  |  12.5 KB  |  585 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Archiving: SaveGame I/O.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24. static const char
  25. rcsid[] = "$Id: p_tick.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
  26.  
  27. #include "i_system.h"
  28. #include "z_zone.h"
  29. #include "p_local.h"
  30.  
  31. // State.
  32. #include "doomstat.h"
  33. #include "r_state.h"
  34.  
  35. byte*        save_p;
  36.  
  37. // Pads save_p to a 4-byte boundary
  38. //  so that the load/save works on SGI&Gecko.
  39. #define PADSAVEP()    save_p += (4 - ((int) save_p & 3)) & 3
  40.  
  41.  
  42. //
  43. // P_ArchivePlayers
  44. //
  45. void P_ArchivePlayers (void)
  46. {
  47.     int        i;
  48.     int        j;
  49.     player_t*    dest;
  50.         
  51.     for (i=0 ; i<MAXPLAYERS ; i++)
  52.     {
  53.     if (!playeringame[i])
  54.         continue;
  55.     
  56.     PADSAVEP();
  57.  
  58.     dest = (player_t *)save_p;
  59.     memcpy (dest,&players[i],sizeof(player_t));
  60.     save_p += sizeof(player_t);
  61.     for (j=0 ; j<NUMPSPRITES ; j++)
  62.     {
  63.         if (dest->psprites[j].state)
  64.         {
  65.         dest->psprites[j].state 
  66.             = (state_t *)(dest->psprites[j].state-states);
  67.         }
  68.     }
  69.     }
  70. }
  71.  
  72.  
  73.  
  74. //
  75. // P_UnArchivePlayers
  76. //
  77. void P_UnArchivePlayers (void)
  78. {
  79.     int        i;
  80.     int        j;
  81.     
  82.     for (i=0 ; i<MAXPLAYERS ; i++)
  83.     {
  84.     if (!playeringame[i])
  85.         continue;
  86.     
  87.     PADSAVEP();
  88.  
  89.     memcpy (&players[i],save_p, sizeof(player_t));
  90.     save_p += sizeof(player_t);
  91.     
  92.     // will be set when unarc thinker
  93.     players[i].mo = NULL;    
  94.     players[i].message = NULL;
  95.     players[i].attacker = NULL;
  96.  
  97.     for (j=0 ; j<NUMPSPRITES ; j++)
  98.     {
  99.         if (players[i]. psprites[j].state)
  100.         {
  101.         players[i]. psprites[j].state 
  102.             = &states[ (int)players[i].psprites[j].state ];
  103.         }
  104.     }
  105.     }
  106. }
  107.  
  108.  
  109. //
  110. // P_ArchiveWorld
  111. //
  112. void P_ArchiveWorld (void)
  113. {
  114.     int            i;
  115.     int            j;
  116.     sector_t*        sec;
  117.     line_t*        li;
  118.     side_t*        si;
  119.     short*        put;
  120.     
  121.     put = (short *)save_p;
  122.     
  123.     // do sectors
  124.     for (i=0, sec = sectors ; i<numsectors ; i++,sec++)
  125.     {
  126.     *put++ = sec->floorheight >> FRACBITS;
  127.     *put++ = sec->ceilingheight >> FRACBITS;
  128.     *put++ = sec->floorpic;
  129.     *put++ = sec->ceilingpic;
  130.     *put++ = sec->lightlevel;
  131.     *put++ = sec->special;        // needed?
  132.     *put++ = sec->tag;        // needed?
  133.     }
  134.  
  135.     
  136.     // do lines
  137.     for (i=0, li = lines ; i<numlines ; i++,li++)
  138.     {
  139.     *put++ = li->flags;
  140.     *put++ = li->special;
  141.     *put++ = li->tag;
  142.     for (j=0 ; j<2 ; j++)
  143.     {
  144.         if (li->sidenum[j] == -1)
  145.         continue;
  146.         
  147.         si = &sides[li->sidenum[j]];
  148.  
  149.         *put++ = si->textureoffset >> FRACBITS;
  150.         *put++ = si->rowoffset >> FRACBITS;
  151.         *put++ = si->toptexture;
  152.         *put++ = si->bottomtexture;
  153.         *put++ = si->midtexture;    
  154.     }
  155.     }
  156.     
  157.     save_p = (byte *)put;
  158. }
  159.  
  160.  
  161.  
  162. //
  163. // P_UnArchiveWorld
  164. //
  165. void P_UnArchiveWorld (void)
  166. {
  167.     int            i;
  168.     int            j;
  169.     sector_t*        sec;
  170.     line_t*        li;
  171.     side_t*        si;
  172.     short*        get;
  173.     
  174.     get = (short *)save_p;
  175.     
  176.     // do sectors
  177.     for (i=0, sec = sectors ; i<numsectors ; i++,sec++)
  178.     {
  179.     sec->floorheight = *get++ << FRACBITS;
  180.     sec->ceilingheight = *get++ << FRACBITS;
  181.     sec->floorpic = *get++;
  182.     sec->ceilingpic = *get++;
  183.     sec->lightlevel = *get++;
  184.     sec->special = *get++;        // needed?
  185.     sec->tag = *get++;        // needed?
  186.     sec->specialdata = 0;
  187.     sec->soundtarget = 0;
  188.     }
  189.     
  190.     // do lines
  191.     for (i=0, li = lines ; i<numlines ; i++,li++)
  192.     {
  193.     li->flags = *get++;
  194.     li->special = *get++;
  195.     li->tag = *get++;
  196.     for (j=0 ; j<2 ; j++)
  197.     {
  198.         if (li->sidenum[j] == -1)
  199.         continue;
  200.         si = &sides[li->sidenum[j]];
  201.         si->textureoffset = *get++ << FRACBITS;
  202.         si->rowoffset = *get++ << FRACBITS;
  203.         si->toptexture = *get++;
  204.         si->bottomtexture = *get++;
  205.         si->midtexture = *get++;
  206.     }
  207.     }
  208.     save_p = (byte *)get;    
  209. }
  210.  
  211.  
  212.  
  213.  
  214.  
  215. //
  216. // Thinkers
  217. //
  218. typedef enum
  219. {
  220.     tc_end,
  221.     tc_mobj
  222.  
  223. } thinkerclass_t;
  224.  
  225.  
  226.  
  227. //
  228. // P_ArchiveThinkers
  229. //
  230. void P_ArchiveThinkers (void)
  231. {
  232.     thinker_t*        th;
  233.     mobj_t*        mobj;
  234.     
  235.     // save off the current thinkers
  236.     for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
  237.     {
  238.     if (th->function.acp1 == (actionf_p1)P_MobjThinker)
  239.     {
  240.         *save_p++ = tc_mobj;
  241.         PADSAVEP();
  242.         mobj = (mobj_t *)save_p;
  243.         memcpy (mobj, th, sizeof(*mobj));
  244.         save_p += sizeof(*mobj);
  245.         mobj->state = (state_t *)(mobj->state - states);
  246.         
  247.         if (mobj->player)
  248.         mobj->player = (player_t *)((mobj->player-players) + 1);
  249.         continue;
  250.     }
  251.         
  252.     // I_Error ("P_ArchiveThinkers: Unknown thinker function");
  253.     }
  254.  
  255.     // add a terminating marker
  256.     *save_p++ = tc_end;    
  257. }
  258.  
  259.  
  260.  
  261. //
  262. // P_UnArchiveThinkers
  263. //
  264. void P_UnArchiveThinkers (void)
  265. {
  266.     byte        tclass;
  267.     thinker_t*        currentthinker;
  268.     thinker_t*        next;
  269.     mobj_t*        mobj;
  270.  
  271.     // remove all the current thinkers
  272.     currentthinker = thinkercap.next;
  273.     while (currentthinker != &thinkercap)
  274.     {
  275.     next = currentthinker->next;
  276.     
  277.     if (currentthinker->function.acp1 == (actionf_p1)P_MobjThinker)
  278.         P_RemoveMobj ((mobj_t *)currentthinker);
  279.     else
  280.         Z_Free (currentthinker);
  281.  
  282.     currentthinker = next;
  283.     }
  284.     P_InitThinkers ();
  285.     
  286.     // read in saved thinkers
  287.     while (1)
  288.     {
  289.     tclass = *save_p++;
  290.     switch (tclass)
  291.     {
  292.       case tc_end:
  293.         return;     // end of list
  294.             
  295.       case tc_mobj:
  296.         PADSAVEP();
  297.         mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
  298.         memcpy (mobj, save_p, sizeof(*mobj));
  299.         save_p += sizeof(*mobj);
  300.         mobj->state = &states[(int)mobj->state];
  301.         mobj->target = NULL;
  302.         if (mobj->player)
  303.         {
  304.         mobj->player = &players[(int)mobj->player-1];
  305.         mobj->player->mo = mobj;
  306.         }
  307.         P_SetThingPosition (mobj);
  308.         mobj->info = &mobjinfo[mobj->type];
  309.         mobj->floorz = mobj->subsector->sector->floorheight;
  310.         mobj->ceilingz = mobj->subsector->sector->ceilingheight;
  311.         mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker;
  312.         P_AddThinker (&mobj->thinker);
  313.         break;
  314.             
  315.       default:
  316.         I_Error ("Unknown tclass %i in savegame",tclass);
  317.     }
  318.     
  319.     }
  320.  
  321. }
  322.  
  323.  
  324. //
  325. // P_ArchiveSpecials
  326. //
  327. enum
  328. {
  329.     tc_ceiling,
  330.     tc_door,
  331.     tc_floor,
  332.     tc_plat,
  333.     tc_flash,
  334.     tc_strobe,
  335.     tc_glow,
  336.     tc_endspecials
  337.  
  338. } specials_e;    
  339.  
  340.  
  341.  
  342. //
  343. // Things to handle:
  344. //
  345. // T_MoveCeiling, (ceiling_t: sector_t * swizzle), - active list
  346. // T_VerticalDoor, (vldoor_t: sector_t * swizzle),
  347. // T_MoveFloor, (floormove_t: sector_t * swizzle),
  348. // T_LightFlash, (lightflash_t: sector_t * swizzle),
  349. // T_StrobeFlash, (strobe_t: sector_t *),
  350. // T_Glow, (glow_t: sector_t *),
  351. // T_PlatRaise, (plat_t: sector_t *), - active list
  352. //
  353. void P_ArchiveSpecials (void)
  354. {
  355.     thinker_t*        th;
  356.     ceiling_t*        ceiling;
  357.     vldoor_t*        door;
  358.     floormove_t*    floor;
  359.     plat_t*        plat;
  360.     lightflash_t*    flash;
  361.     strobe_t*        strobe;
  362.     glow_t*        glow;
  363.     int            i;
  364.     
  365.     // save off the current thinkers
  366.     for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
  367.     {
  368.     if (th->function.acv == (actionf_v)NULL)
  369.     {
  370.         for (i = 0; i < MAXCEILINGS;i++)
  371.         if (activeceilings[i] == (ceiling_t *)th)
  372.             break;
  373.         
  374.         if (i<MAXCEILINGS)
  375.         {
  376.         *save_p++ = tc_ceiling;
  377.         PADSAVEP();
  378.         ceiling = (ceiling_t *)save_p;
  379.         memcpy (ceiling, th, sizeof(*ceiling));
  380.         save_p += sizeof(*ceiling);
  381.         ceiling->sector = (sector_t *)(ceiling->sector - sectors);
  382.         }
  383.         continue;
  384.     }
  385.             
  386.     if (th->function.acp1 == (actionf_p1)T_MoveCeiling)
  387.     {
  388.         *save_p++ = tc_ceiling;
  389.         PADSAVEP();
  390.         ceiling = (ceiling_t *)save_p;
  391.         memcpy (ceiling, th, sizeof(*ceiling));
  392.         save_p += sizeof(*ceiling);
  393.         ceiling->sector = (sector_t *)(ceiling->sector - sectors);
  394.         continue;
  395.     }
  396.             
  397.     if (th->function.acp1 == (actionf_p1)T_VerticalDoor)
  398.     {
  399.         *save_p++ = tc_door;
  400.         PADSAVEP();
  401.         door = (vldoor_t *)save_p;
  402.         memcpy (door, th, sizeof(*door));
  403.         save_p += sizeof(*door);
  404.         door->sector = (sector_t *)(door->sector - sectors);
  405.         continue;
  406.     }
  407.             
  408.     if (th->function.acp1 == (actionf_p1)T_MoveFloor)
  409.     {
  410.         *save_p++ = tc_floor;
  411.         PADSAVEP();
  412.         floor = (floormove_t *)save_p;
  413.         memcpy (floor, th, sizeof(*floor));
  414.         save_p += sizeof(*floor);
  415.         floor->sector = (sector_t *)(floor->sector - sectors);
  416.         continue;
  417.     }
  418.             
  419.     if (th->function.acp1 == (actionf_p1)T_PlatRaise)
  420.     {
  421.         *save_p++ = tc_plat;
  422.         PADSAVEP();
  423.         plat = (plat_t *)save_p;
  424.         memcpy (plat, th, sizeof(*plat));
  425.         save_p += sizeof(*plat);
  426.         plat->sector = (sector_t *)(plat->sector - sectors);
  427.         continue;
  428.     }
  429.             
  430.     if (th->function.acp1 == (actionf_p1)T_LightFlash)
  431.     {
  432.         *save_p++ = tc_flash;
  433.         PADSAVEP();
  434.         flash = (lightflash_t *)save_p;
  435.         memcpy (flash, th, sizeof(*flash));
  436.         save_p += sizeof(*flash);
  437.         flash->sector = (sector_t *)(flash->sector - sectors);
  438.         continue;
  439.     }
  440.             
  441.     if (th->function.acp1 == (actionf_p1)T_StrobeFlash)
  442.     {
  443.         *save_p++ = tc_strobe;
  444.         PADSAVEP();
  445.         strobe = (strobe_t *)save_p;
  446.         memcpy (strobe, th, sizeof(*strobe));
  447.         save_p += sizeof(*strobe);
  448.         strobe->sector = (sector_t *)(strobe->sector - sectors);
  449.         continue;
  450.     }
  451.             
  452.     if (th->function.acp1 == (actionf_p1)T_Glow)
  453.     {
  454.         *save_p++ = tc_glow;
  455.         PADSAVEP();
  456.         glow = (glow_t *)save_p;
  457.         memcpy (glow, th, sizeof(*glow));
  458.         save_p += sizeof(*glow);
  459.         glow->sector = (sector_t *)(glow->sector - sectors);
  460.         continue;
  461.     }
  462.     }
  463.     
  464.     // add a terminating marker
  465.     *save_p++ = tc_endspecials;    
  466.  
  467. }
  468.  
  469.  
  470. //
  471. // P_UnArchiveSpecials
  472. //
  473. void P_UnArchiveSpecials (void)
  474. {
  475.     byte        tclass;
  476.     ceiling_t*        ceiling;
  477.     vldoor_t*        door;
  478.     floormove_t*    floor;
  479.     plat_t*        plat;
  480.     lightflash_t*    flash;
  481.     strobe_t*        strobe;
  482.     glow_t*        glow;
  483.     
  484.     
  485.     // read in saved thinkers
  486.     while (1)
  487.     {
  488.     tclass = *save_p++;
  489.     switch (tclass)
  490.     {
  491.       case tc_endspecials:
  492.         return;    // end of list
  493.             
  494.       case tc_ceiling:
  495.         PADSAVEP();
  496.         ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVEL, NULL);
  497.         memcpy (ceiling, save_p, sizeof(*ceiling));
  498.         save_p += sizeof(*ceiling);
  499.         ceiling->sector = §ors[(int)ceiling->sector];
  500.         ceiling->sector->specialdata = ceiling;
  501.  
  502.         if (ceiling->thinker.function.acp1)
  503.         ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
  504.  
  505.         P_AddThinker (&ceiling->thinker);
  506.         P_AddActiveCeiling(ceiling);
  507.         break;
  508.                 
  509.       case tc_door:
  510.         PADSAVEP();
  511.         door = Z_Malloc (sizeof(*door), PU_LEVEL, NULL);
  512.         memcpy (door, save_p, sizeof(*door));
  513.         save_p += sizeof(*door);
  514.         door->sector = §ors[(int)door->sector];
  515.         door->sector->specialdata = door;
  516.         door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
  517.         P_AddThinker (&door->thinker);
  518.         break;
  519.                 
  520.       case tc_floor:
  521.         PADSAVEP();
  522.         floor = Z_Malloc (sizeof(*floor), PU_LEVEL, NULL);
  523.         memcpy (floor, save_p, sizeof(*floor));
  524.         save_p += sizeof(*floor);
  525.         floor->sector = §ors[(int)floor->sector];
  526.         floor->sector->specialdata = floor;
  527.         floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
  528.         P_AddThinker (&floor->thinker);
  529.         break;
  530.                 
  531.       case tc_plat:
  532.         PADSAVEP();
  533.         plat = Z_Malloc (sizeof(*plat), PU_LEVEL, NULL);
  534.         memcpy (plat, save_p, sizeof(*plat));
  535.         save_p += sizeof(*plat);
  536.         plat->sector = §ors[(int)plat->sector];
  537.         plat->sector->specialdata = plat;
  538.  
  539.         if (plat->thinker.function.acp1)
  540.         plat->thinker.function.acp1 = (actionf_p1)T_PlatRaise;
  541.  
  542.         P_AddThinker (&plat->thinker);
  543.         P_AddActivePlat(plat);
  544.         break;
  545.                 
  546.       case tc_flash:
  547.         PADSAVEP();
  548.         flash = Z_Malloc (sizeof(*flash), PU_LEVEL, NULL);
  549.         memcpy (flash, save_p, sizeof(*flash));
  550.         save_p += sizeof(*flash);
  551.         flash->sector = §ors[(int)flash->sector];
  552.         flash->thinker.function.acp1 = (actionf_p1)T_LightFlash;
  553.         P_AddThinker (&flash->thinker);
  554.         break;
  555.                 
  556.       case tc_strobe:
  557.         PADSAVEP();
  558.         strobe = Z_Malloc (sizeof(*strobe), PU_LEVEL, NULL);
  559.         memcpy (strobe, save_p, sizeof(*strobe));
  560.         save_p += sizeof(*strobe);
  561.         strobe->sector = §ors[(int)strobe->sector];
  562.         strobe->thinker.function.acp1 = (actionf_p1)T_StrobeFlash;
  563.         P_AddThinker (&strobe->thinker);
  564.         break;
  565.                 
  566.       case tc_glow:
  567.         PADSAVEP();
  568.         glow = Z_Malloc (sizeof(*glow), PU_LEVEL, NULL);
  569.         memcpy (glow, save_p, sizeof(*glow));
  570.         save_p += sizeof(*glow);
  571.         glow->sector = §ors[(int)glow->sector];
  572.         glow->thinker.function.acp1 = (actionf_p1)T_Glow;
  573.         P_AddThinker (&glow->thinker);
  574.         break;
  575.                 
  576.       default:
  577.         I_Error ("P_UnarchiveSpecials:Unknown tclass %i "
  578.              "in savegame",tclass);
  579.     }
  580.     
  581.     }
  582.  
  583. }
  584.  
  585.